#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct SNode *PtrToSNode;
typedef int ElementType;
struct SNode {
    ElementType Data;
    PtrToSNode Next;
};
typedef PtrToSNode Stack;

Stack CreateStack();

bool IsEmpty(Stack S);

bool Push(Stack S, ElementType X);

ElementType Pop(Stack S);
int main()
{
 
    int M,N,K,Data;
    bool Mark_check=true;
    bool Max_num=false,Max_size=false;
    //M:maximum capacity of the stack
    //N:length of push sequence
    //K:the number of pop sequences to be checked
    scanf("%d %d %d", &M, &N, &K);
    for (int i = 0; i < K; i++)
    {
        /*  ---------------- INIT --------------------- */
        Stack S_orig = CreateStack();
        Push(S_orig, 1);
        int S_data = 2,count_size=1;
        Max_num = false;
        Max_size = false;
        Mark_check = true;
        /*  ---------------- INIT --------------------- */

        for (int j = 0; j < N; j++)
        {
            scanf("%d", &Data);
            if(Mark_check)
            {
                if(IsEmpty(S_orig)&&!Max_num&&!Max_size)
                {
                    Push(S_orig, S_data);
                    S_data++;
                    count_size++;
                }
                while(Data != S_orig->Next->Data&&!Max_num&&!Max_size)
                {
                    Push(S_orig, S_data);
                    Mark_check = false;
                    S_data++;
                    count_size++;
                    Max_size = count_size >= M ? true : false;
                }
                if(Data == S_orig->Next->Data)
                {
                    Pop(S_orig);
                    count_size--;
                    Mark_check=true;
                }
                else
                {
                    Mark_check=false;
                }
                if(S_data>N)
                    Max_num = true;
                Max_size = count_size > M ? true : false;
            }
        }
        if(Mark_check)
            printf("YES\n");
        else
            printf("NO\n");
    }
    // printf("DONE\n");
    return 0;
}

Stack CreateStack() 
{ /* 构建一个堆栈的头结点，返回该结点指针 */
    Stack S;

    S = (Stack)malloc(sizeof(struct SNode));
    S->Next = NULL;
    return S;
}

bool IsEmpty ( Stack S )
{ /* 判断堆栈S是否为空，若是返回true；否则返回false */
    return ( S->Next == NULL );
}

// bool Push( Stack S, ElementType X )
// { /* 将元素X压入堆栈S */
//     PtrToSNode TmpCell;

//     TmpCell = (PtrToSNode)malloc(sizeof(struct SNode));
//     TmpCell->Data = X;
//     TmpCell->Next = S->Next;
//     S->Next = TmpCell;
//     return true;
// }
// ElementType Pop( Stack S )  
// { /* 删除并返回堆栈S的栈顶元素 */
//     PtrToSNode FirstCell;
//     ElementType TopElem;

//     if( IsEmpty(S) ) {
//         printf("堆栈空"); 
//         return -1;
//     }
//     else {
//         FirstCell = S->Next; 
//         TopElem = FirstCell->Data;
//         S->Next = FirstCell->Next;
//         free(FirstCell);
//         return TopElem;
//     }
// }

// bool Push( Stack S, ElementType X )
// {
//     PtrToSNode Temp;
//     Temp = (PtrToSNode)malloc(sizeof(struct SNode));
//     Temp->Data = X;
//     Temp->Next = S;
//     S->Next = Temp;
//     return true;
// }
// ElementType Pop( Stack S )
// {
//     PtrToSNode FirstCell;
//     if(IsEmpty(S))
//         return false;
//     else
//     {
//         FirstCell = S->Next;
//         S->Next = FirstCell->Next;
//         free(FirstCell);

//     }
// }